home *** CD-ROM | disk | FTP | other *** search
/ Languguage OS 2 / Languguage OS II Version 10-94 (Knowledge Media)(1994).ISO / a_utils / expanded.lha / test_suite / testsub.C < prev    next >
C/C++ Source or Header  |  1992-03-19  |  28KB  |  942 lines
  1. //
  2. // Linear-Affine-Projective Geometry Package
  3. //
  4. // testsub.C
  5. //
  6. // $Header$
  7. //
  8. // William J.R. Longabaugh 
  9. // University of Washington
  10. //
  11. // Test runs for the linear-affine-projective geometry
  12. // package described in William J.R. Longabaugh, "An Expanded
  13. // System for Coordinate-Free Geometric Programming", Master's 
  14. // thesis, University of Washington, 1992.
  15. //
  16. // Copyright (c) 1992, William J.R. Longabaugh
  17. //   Copying, use and development for non-commercial purposes permitted.
  18. //   All rights for commercial use reserved.
  19. //   This software is unsupported and without warranty; it is
  20. //   provided "as is".
  21. //
  22. // ***********************************************************************
  23.  
  24. #include "Lap.h"
  25. #include <math.h>
  26.  
  27. extern void test1(void);
  28. extern void truth(Boolean res, Boolean expect);
  29. extern void beauty(void);
  30.  
  31. static int count = 0;
  32.  
  33. // ***********************************************************************
  34.  
  35. int main(void)
  36. {
  37.   test1();
  38.   return (0);
  39. }
  40.  
  41. // ***********************************************************************
  42.  
  43. void truth(Boolean res, Boolean expect)
  44. {
  45.   if (res != expect) { 
  46.     cout << "Failure at: " << count << "\n";
  47.   }
  48.   count++;    
  49. }
  50.  
  51. // ***********************************************************************
  52.  
  53. void beauty(void)
  54. {
  55.   cout << "Now at: " << count << "\n";
  56. }
  57.  
  58. // ***********************************************************************
  59. // Test the constructors for subsets
  60.  
  61. void test1(void)
  62. {
  63.   cout << "ENTERING TEST1\n";
  64.   VSpace v("Test vector space", 4, TRUE);
  65.   ASpace a("Test affine space", 3, TRUE);
  66.   PSpace p("Test projective space", v, a);
  67.   VSpace t = a.GetSpace(TANGENT);
  68.   Frame fra = a.StdBasis();
  69.   VBasis vbas = v.StdBasis();
  70.   HFrame hfr = p.StdBasis();
  71.   VBasis tbas = t.StdBasis();
  72.  
  73.   Vector v1(vbas, ScalarList(6.7, 3.4, 2.8, 1.2));
  74.   Vector v2(vbas, ScalarList(2.5, 5.7, 1.3, 9.5));
  75.   Vector v3(vbas, ScalarList(7.9, 3.5, 4.1, 2.7));
  76.   Vector v4(vbas, ScalarList(7.3, 4.6, 2.2, 9.3));
  77.   VectorEC v1ec = v1.MapTo(VEC_EC);
  78.   VectorEC v2ec = v2.MapTo(VEC_EC);
  79.   VectorEC v3ec = v3.MapTo(VEC_EC);
  80.   VectorEC v4ec = v4.MapTo(VEC_EC);
  81.  
  82.   APoint p1(fra, ScalarList(6.7, 3.4, 2.8, 1.0));
  83.   APoint p2(fra, ScalarList(3.6, 2.5, -2.1, 1.0));
  84.   APoint p3(fra, ScalarList(2.2, 1.9, -0.3, 1.0));
  85.   APoint p4(fra, ScalarList(2.5, 1.6, 7.4, 1.0));
  86.  
  87.   AVector t1(tbas, ScalarList(3.4, 2.8, 1.2));
  88.   AVector t2(tbas, ScalarList(2.5, 1.3, 9.5));
  89.   AVector t3(tbas, ScalarList(7.9, 3.5, 2.7));
  90.   AVectorEC t1ec = t1.MapTo(AFF_VEC_EC);
  91.   AVectorEC t2ec = t2.MapTo(AFF_VEC_EC);
  92.   AVectorEC t3ec = t3.MapTo(AFF_VEC_EC);
  93.  
  94.   PPoint pp1(hfr, ScalarList(6.7, 3.4, 2.8, 3.4));
  95.   PPoint pp2(hfr, ScalarList(3.6, 2.5, -2.1, 3.1));
  96.   PPoint pp3(hfr, ScalarList(2.2, 1.9, -0.3, 5.1));
  97.   PPoint pp4(hfr, ScalarList(7.4, 1.0, 2.5, 1.6));
  98.  
  99.   VSubSet vs1d("vs1d", v, GeObList(v1));
  100.   VSubSet vs2d("vs2d", v, GeObList(v1, v2));
  101.   VSubSet vs3d("vs3d", v, GeObList(v1, v2, v3));
  102.   VSubSet vs4d("vs4d", v, GeObList(v1, v2, v3, v4));
  103.  
  104.   VSubSet ts1d("ts1d", t, GeObList(t1));
  105.   VSubSet ts2d("ts2d", t, GeObList(t1, t2));
  106.   VSubSet ts3d("ts3d", t, GeObList(t1, t2, t3));
  107.  
  108.   ASubSet as0dv("as0dv", v, GeObList(v1));
  109.   ASubSet as1dv("as1dv", v, GeObList(v1, v2));
  110.   ASubSet as2dv("as2dv", v, GeObList(v1, v2, v3));
  111.   ASubSet as3dv("as3dv", v, GeObList(v1, v2, v3, v4));
  112.  
  113.   ASubSet as0dt("as0dt", t, GeObList(t1));
  114.   ASubSet as1dt("as1dt", t, GeObList(t1, t2));
  115.   ASubSet as2dt("as2dt", t, GeObList(t1, t2, t3));
  116.  
  117.   ASubSet as0da("as0da", a, GeObList(p1));
  118.   ASubSet as1da("as1da", a, GeObList(p1, p2));
  119.   ASubSet as2da("as2da", a, GeObList(p1, p2, p3));
  120.   Vector hold = p3.MapTo(VECTOR);
  121.   ASubSet as3da("as3da", a, GeObList(p1, p2, hold, p4));
  122.  
  123.   ASubSet as1dp("as1dp", p, pp1, GeObList(pp2));
  124.   ASubSet as2dp("as2dp", p, pp1, GeObList(pp2, pp3));
  125.   VectorEC holdec = pp3.MapTo(VEC_EC);
  126.   ASubSet as3dp("as3dp", p, pp1, GeObList(pp2, holdec, pp4));
  127.  
  128.   PSubSet ps0dp("ps0dp", p, GeObList(pp1));
  129.   PSubSet ps1dp("ps1dp", p, GeObList(pp1, pp2));
  130.   PSubSet ps2dp("ps2dp", p, GeObList(pp1, pp2, pp3));
  131.   PSubSet ps3dp("ps3dp", p, GeObList(pp1, pp2, holdec, pp4));
  132.  
  133.   PSubSet ps0dv("ps0dp", v, GeObList(v1ec));
  134.   PSubSet ps1dv("ps1dp", v, GeObList(v1ec, v2ec));
  135.   PSubSet ps2dv("ps2dp", v, GeObList(v1ec, v2ec, v3ec));
  136.   PSubSet ps3dv("ps3dp", v, GeObList(v1ec, v2, v3ec, v4ec));
  137.  
  138.   PSubSet ps0dt("ps0dt", t, GeObList(t1ec));
  139.   PSubSet ps1dt("ps1dt", t, GeObList(t1ec, t2ec));
  140.   PSubSet ps2dt("ps2dt", t, GeObList(t1ec, t2, t3ec));
  141.  
  142.   PSubSet ps0dprmt("0d line", p, GeObList(pp1), GeObList(pp2));
  143.   PSubSet ps0dprml("0d plane", p, GeObList(pp1, pp2), GeObList(pp3));
  144.   PSubSet ps0dprmp("0d space", p, GeObList(pp1, pp2, pp3), GeObList(pp4));
  145.   PSubSet ps1dprmt("pencil of lines", p, GeObList(pp1), GeObList(pp2, pp3));
  146.   PSubSet ps1dprml("pencil of planes", p, GeObList(pp1, pp2),
  147.            GeObList(pp3, pp4));
  148.   PSubSet ps2dprmt("bundle of lines", p, GeObList(pp1), 
  149.            GeObList(pp2, holdec, pp4));
  150.  
  151.   PSubSet ps0dvrmt("0d line v", v, GeObList(v1ec), GeObList(v2ec));
  152.   PSubSet ps0dvrml("0d plane v", v, GeObList(v1ec, v2ec), GeObList(v3ec));
  153.   PSubSet ps0dvrmp("0d space v", v, GeObList(v1ec, v2ec, v3ec),
  154.            GeObList(v4ec));
  155.   PSubSet ps1dvrmt("pencil of lines v", v, GeObList(v1ec),
  156.            GeObList(v2ec, v3ec));
  157.   PSubSet ps1dvrml("pencil of planes v", v, GeObList(v1ec, v2),
  158.            GeObList(v3ec, v4ec));
  159.   PSubSet ps2dvrmt("bundle of lines v", v, GeObList(v1ec), 
  160.            GeObList(v2, v3ec, v4ec));
  161.  
  162.   PSubSet ps0dtrmt("0d line t", t, GeObList(t1ec), GeObList(t2));
  163.   PSubSet ps0dtrml("0d plane t", t, GeObList(t1ec, t2), GeObList(t3ec));
  164.   PSubSet ps1dtrmt("pencil of lines t", t, GeObList(t1ec),
  165.            GeObList(t2, t3ec));
  166.  
  167. // Vector subsets of vector spaces:
  168.  
  169.   beauty();
  170.   truth(vs1d.Accepts() == VECTOR, TRUE);
  171.   truth(vs2d.Accepts() == VECTOR, TRUE);
  172.   truth(vs3d.Accepts() == VECTOR, TRUE);
  173.   truth(vs4d.Accepts() == VECTOR, TRUE);
  174.  
  175.   truth(vs1d.IsFullSpace(), FALSE);
  176.   truth(vs2d.IsFullSpace(), FALSE);
  177.   truth(vs3d.IsFullSpace(), FALSE);
  178.   truth(vs4d.IsFullSpace(), TRUE);
  179.  
  180.   truth(vs1d.IsSubset(vs1d), TRUE);
  181.   truth(vs2d.IsSubset(vs1d), TRUE);
  182.   truth(vs3d.IsSubset(vs1d), TRUE);
  183.   truth(vs4d.IsSubset(vs1d), TRUE);
  184.  
  185.   truth(vs1d.IsSubset(vs2d), FALSE);
  186.   truth(vs2d.IsSubset(vs2d), TRUE);
  187.   truth(vs3d.IsSubset(vs2d), TRUE);
  188.   truth(vs4d.IsSubset(vs2d), TRUE);
  189.  
  190.   truth(vs1d.IsSubset(vs3d), FALSE);
  191.   truth(vs2d.IsSubset(vs3d), FALSE);
  192.   truth(vs3d.IsSubset(vs3d), TRUE);
  193.   truth(vs4d.IsSubset(vs3d), TRUE);
  194.  
  195.   truth(vs1d.IsSubset(vs4d), FALSE);
  196.   truth(vs2d.IsSubset(vs4d), FALSE);
  197.   truth(vs3d.IsSubset(vs4d), FALSE);
  198.   truth(vs4d.IsSubset(vs4d), TRUE);
  199.  
  200.   VSubSet vfs = v.FullSet(); 
  201.   truth(vs4d.IsSubset(vfs), TRUE);
  202.   truth(vfs.IsSubset(vs4d), TRUE);
  203.  
  204.   truth(vs1d.IsIn(v1), TRUE);
  205.   truth(vs1d.IsIn(v2), FALSE);
  206.   truth(vs1d.IsIn(v3), FALSE);
  207.   truth(vs1d.IsIn(v4), FALSE);
  208.  
  209.   truth(vs2d.IsIn(v1), TRUE);
  210.   truth(vs2d.IsIn(v2), TRUE);
  211.   truth(vs2d.IsIn(v3), FALSE);
  212.   truth(vs2d.IsIn(v4), FALSE);
  213.  
  214.   truth(vs3d.IsIn(v1), TRUE);
  215.   truth(vs3d.IsIn(v2), TRUE);
  216.   truth(vs3d.IsIn(v3), TRUE);
  217.   truth(vs3d.IsIn(v4), FALSE);
  218.  
  219.   truth(vs4d.IsIn(v1), TRUE);
  220.   truth(vs4d.IsIn(v2), TRUE);
  221.   truth(vs4d.IsIn(v3), TRUE);
  222.   truth(vs4d.IsIn(v4), TRUE);
  223.  
  224. // Vector subsets of tangent vector spaces:
  225.  
  226.   beauty();
  227.   truth(ts1d.Accepts() == AFF_VECTOR, TRUE);
  228.   truth(ts2d.Accepts() == AFF_VECTOR, TRUE);
  229.   truth(ts3d.Accepts() == AFF_VECTOR, TRUE);
  230.  
  231.   truth(ts1d.IsFullSpace(), FALSE);
  232.   truth(ts2d.IsFullSpace(), FALSE);
  233.   truth(ts3d.IsFullSpace(), TRUE);
  234.  
  235.   truth(ts1d.IsSubset(ts1d), TRUE);
  236.   truth(ts2d.IsSubset(ts1d), TRUE);
  237.   truth(ts3d.IsSubset(ts1d), TRUE);
  238.  
  239.   truth(ts1d.IsSubset(ts2d), FALSE);
  240.   truth(ts2d.IsSubset(ts2d), TRUE);
  241.   truth(ts3d.IsSubset(ts2d), TRUE);
  242.  
  243.   truth(ts1d.IsSubset(ts3d), FALSE);
  244.   truth(ts2d.IsSubset(ts3d), FALSE);
  245.   truth(ts3d.IsSubset(ts3d), TRUE);
  246.  
  247.   VSubSet tfs = t.FullSet(); 
  248.   truth(ts3d.IsSubset(tfs), TRUE);
  249.   truth(tfs.IsSubset(ts3d), TRUE);
  250.  
  251.   truth(ts1d.IsIn(t1), TRUE);
  252.   truth(ts1d.IsIn(t2), FALSE);
  253.   truth(ts1d.IsIn(t3), FALSE);
  254.  
  255.   truth(ts2d.IsIn(t1), TRUE);
  256.   truth(ts2d.IsIn(t2), TRUE);
  257.   truth(ts2d.IsIn(t3), FALSE);
  258.  
  259.   truth(ts3d.IsIn(t1), TRUE);
  260.   truth(ts3d.IsIn(t2), TRUE);
  261.   truth(ts3d.IsIn(t3), TRUE);
  262.  
  263. // Affine subsets of vector spaces:
  264.  
  265.   beauty();
  266.   truth(as0dv.Accepts() == VECTOR, TRUE);
  267.   truth(as1dv.Accepts() == VECTOR, TRUE);
  268.   truth(as2dv.Accepts() == VECTOR, TRUE);
  269.   truth(as3dv.Accepts() == VECTOR, TRUE);
  270.  
  271.   truth(as0dv.IsFullSpace(), FALSE);
  272.   truth(as1dv.IsFullSpace(), FALSE);
  273.   truth(as2dv.IsFullSpace(), FALSE);
  274.   truth(as3dv.IsFullSpace(), FALSE);
  275.  
  276.   truth(as0dv.IsSubset(as0dv), TRUE);
  277.   truth(as1dv.IsSubset(as0dv), TRUE);
  278.   truth(as2dv.IsSubset(as0dv), TRUE);
  279.   truth(as3dv.IsSubset(as0dv), TRUE);
  280.  
  281.   truth(as0dv.IsSubset(as1dv), FALSE);
  282.   truth(as1dv.IsSubset(as1dv), TRUE);
  283.   truth(as2dv.IsSubset(as1dv), TRUE);
  284.   truth(as3dv.IsSubset(as1dv), TRUE);
  285.  
  286.   truth(as0dv.IsSubset(as2dv), FALSE);
  287.   truth(as1dv.IsSubset(as2dv), FALSE);
  288.   truth(as2dv.IsSubset(as2dv), TRUE);
  289.   truth(as3dv.IsSubset(as2dv), TRUE);
  290.  
  291.   truth(as0dv.IsSubset(as3dv), FALSE);
  292.   truth(as1dv.IsSubset(as3dv), FALSE);
  293.   truth(as2dv.IsSubset(as3dv), FALSE);
  294.   truth(as3dv.IsSubset(as3dv), TRUE);
  295.  
  296.   truth(as0dv.IsIn(v1), TRUE);
  297.   truth(as0dv.IsIn(v2), FALSE);
  298.   truth(as0dv.IsIn(v3), FALSE);
  299.   truth(as0dv.IsIn(v4), FALSE);
  300.  
  301.   truth(as1dv.IsIn(v1), TRUE);
  302.   truth(as1dv.IsIn(v2), TRUE);
  303.   truth(as1dv.IsIn(v3), FALSE);
  304.   truth(as1dv.IsIn(v4), FALSE);
  305.  
  306.   truth(as2dv.IsIn(v1), TRUE);
  307.   truth(as2dv.IsIn(v2), TRUE);
  308.   truth(as2dv.IsIn(v3), TRUE);
  309.   truth(as2dv.IsIn(v4), FALSE);
  310.  
  311.   truth(as3dv.IsIn(v1), TRUE);
  312.   truth(as3dv.IsIn(v2), TRUE);
  313.   truth(as3dv.IsIn(v3), TRUE);
  314.   truth(as3dv.IsIn(v4), TRUE);
  315.  
  316. // Associated tangent subsets:
  317.  
  318.   VSubSet vtans0 = as0dv.TangentSub();  
  319.   VSubSet vtans1 = as1dv.TangentSub();  
  320.   VSubSet vtans2 = as2dv.TangentSub();  
  321.   VSubSet vtans3 = as3dv.TangentSub();  
  322.  
  323.   beauty();
  324.   truth(vtans0.Accepts() == VECTOR, TRUE);
  325.   truth(vtans1.Accepts() == VECTOR, TRUE);
  326.   truth(vtans2.Accepts() == VECTOR, TRUE);
  327.   truth(vtans3.Accepts() == VECTOR, TRUE);
  328.  
  329.   truth(vtans0.IsFullSpace(), FALSE);
  330.   truth(vtans1.IsFullSpace(), FALSE);
  331.   truth(vtans2.IsFullSpace(), FALSE);
  332.   truth(vtans3.IsFullSpace(), FALSE);
  333.  
  334.   truth(vtans0.IsSubset(vtans0), TRUE);
  335.   truth(vtans1.IsSubset(vtans0), TRUE);
  336.   truth(vtans2.IsSubset(vtans0), TRUE);
  337.   truth(vtans3.IsSubset(vtans0), TRUE);
  338.  
  339.   truth(vtans0.IsSubset(vtans1), FALSE);
  340.   truth(vtans1.IsSubset(vtans1), TRUE);
  341.   truth(vtans2.IsSubset(vtans1), TRUE);
  342.   truth(vtans3.IsSubset(vtans1), TRUE);
  343.  
  344.   truth(vtans0.IsSubset(vtans2), FALSE);
  345.   truth(vtans1.IsSubset(vtans2), FALSE);
  346.   truth(vtans2.IsSubset(vtans2), TRUE);
  347.   truth(vtans3.IsSubset(vtans2), TRUE);
  348.  
  349.   truth(vtans0.IsSubset(vtans3), FALSE);
  350.   truth(vtans1.IsSubset(vtans3), FALSE);
  351.   truth(vtans2.IsSubset(vtans3), FALSE);
  352.   truth(vtans3.IsSubset(vtans3), TRUE);
  353.  
  354.   truth(vtans0.IsIn(v1 - v1), TRUE);
  355.   truth(vtans0.IsIn(v2 - v1), FALSE);
  356.   truth(vtans0.IsIn(v3 - v1), FALSE);
  357.   truth(vtans0.IsIn(v4 - v1), FALSE);
  358.  
  359.   truth(vtans1.IsIn(v1 - v1), TRUE);
  360.   truth(vtans1.IsIn(v2 - v1), TRUE);
  361.   truth(vtans1.IsIn(v3 - v1), FALSE);
  362.   truth(vtans1.IsIn(v4 - v1), FALSE);
  363.  
  364.   truth(vtans2.IsIn(v1 - v1), TRUE);
  365.   truth(vtans2.IsIn(v2 - v1), TRUE);
  366.   truth(vtans2.IsIn(v3 - v1), TRUE);
  367.   truth(vtans2.IsIn(v4 - v1), FALSE);
  368.  
  369.   truth(vtans3.IsIn(v1 - v1), TRUE);
  370.   truth(vtans3.IsIn(v2 - v1), TRUE);
  371.   truth(vtans3.IsIn(v3 - v1), TRUE);
  372.   truth(vtans3.IsIn(v4 - v1), TRUE);
  373.  
  374. // Affine subsets of affine spaces:
  375.  
  376.   beauty();
  377.   truth(as0da.Accepts() == AFF_POINT, TRUE);
  378.   truth(as1da.Accepts() == AFF_POINT, TRUE);
  379.   truth(as2da.Accepts() == AFF_POINT, TRUE);
  380.   truth(as3da.Accepts() == AFF_POINT, TRUE);
  381.  
  382.   truth(as0da.IsFullSpace(), FALSE);
  383.   truth(as1da.IsFullSpace(), FALSE);
  384.   truth(as2da.IsFullSpace(), FALSE);
  385.   truth(as3da.IsFullSpace(), TRUE);
  386.  
  387.   truth(as0da.IsSubset(as0da), TRUE);
  388.   truth(as1da.IsSubset(as0da), TRUE);
  389.   truth(as2da.IsSubset(as0da), TRUE);
  390.   truth(as3da.IsSubset(as0da), TRUE);
  391.  
  392.   truth(as0da.IsSubset(as1da), FALSE);
  393.   truth(as1da.IsSubset(as1da), TRUE);
  394.   truth(as2da.IsSubset(as1da), TRUE);
  395.   truth(as3da.IsSubset(as1da), TRUE);
  396.  
  397.   truth(as0da.IsSubset(as2da), FALSE);
  398.   truth(as1da.IsSubset(as2da), FALSE);
  399.   truth(as2da.IsSubset(as2da), TRUE);
  400.   truth(as3da.IsSubset(as2da), TRUE);
  401.  
  402.   truth(as0da.IsSubset(as3da), FALSE);
  403.   truth(as1da.IsSubset(as3da), FALSE);
  404.   truth(as2da.IsSubset(as3da), FALSE);
  405.   truth(as3da.IsSubset(as3da), TRUE);
  406.  
  407.   ASubSet afs = a.FullSet(); 
  408.   truth(as3da.IsSubset(afs), TRUE);
  409.   truth(afs.IsSubset(as3da), TRUE);
  410.  
  411.   truth(as0da.IsIn(p1), TRUE);
  412.   truth(as0da.IsIn(p2), FALSE);
  413.   truth(as0da.IsIn(hold), FALSE);
  414.   truth(as0da.IsIn(p4), FALSE);
  415.  
  416.   truth(as1da.IsIn(p1), TRUE);
  417.   truth(as1da.IsIn(p2), TRUE);
  418.   truth(as1da.IsIn(hold), FALSE);
  419.   truth(as1da.IsIn(p4), FALSE);
  420.  
  421.   truth(as2da.IsIn(p1), TRUE);
  422.   truth(as2da.IsIn(p2), TRUE);
  423.   truth(as2da.IsIn(hold), TRUE);
  424.   truth(as2da.IsIn(p4), FALSE);
  425.  
  426.   truth(as3da.IsIn(p1), TRUE);
  427.   truth(as3da.IsIn(p2), TRUE);
  428.   truth(as3da.IsIn(hold), TRUE);
  429.   truth(as3da.IsIn(p4), TRUE);
  430.  
  431. // Associated tangent subsets:
  432.  
  433.   VSubSet atans0 = as0da.TangentSub();  
  434.   VSubSet atans1 = as1da.TangentSub();  
  435.   VSubSet atans2 = as2da.TangentSub();  
  436.   VSubSet atans3 = as3da.TangentSub();  
  437.  
  438.   beauty();
  439.   truth(atans0.Accepts() == AFF_VECTOR, TRUE);
  440.   truth(atans1.Accepts() == AFF_VECTOR, TRUE);
  441.   truth(atans2.Accepts() == AFF_VECTOR, TRUE);
  442.   truth(atans3.Accepts() == AFF_VECTOR, TRUE);
  443.  
  444.   truth(atans0.IsFullSpace(), FALSE);
  445.   truth(atans1.IsFullSpace(), FALSE);
  446.   truth(atans2.IsFullSpace(), FALSE);
  447.   truth(atans3.IsFullSpace(), TRUE);
  448.  
  449.   truth(atans0.IsSubset(atans0), TRUE);
  450.   truth(atans1.IsSubset(atans0), TRUE);
  451.   truth(atans2.IsSubset(atans0), TRUE);
  452.   truth(atans3.IsSubset(atans0), TRUE);
  453.  
  454.   truth(atans0.IsSubset(atans1), FALSE);
  455.   truth(atans1.IsSubset(atans1), TRUE);
  456.   truth(atans2.IsSubset(atans1), TRUE);
  457.   truth(atans3.IsSubset(atans1), TRUE);
  458.  
  459.   truth(atans0.IsSubset(atans2), FALSE);
  460.   truth(atans1.IsSubset(atans2), FALSE);
  461.   truth(atans2.IsSubset(atans2), TRUE);
  462.   truth(atans3.IsSubset(atans2), TRUE);
  463.  
  464.   truth(atans0.IsSubset(atans3), FALSE);
  465.   truth(atans1.IsSubset(atans3), FALSE);
  466.   truth(atans2.IsSubset(atans3), FALSE);
  467.   truth(atans3.IsSubset(atans3), TRUE);
  468.  
  469.   VSubSet tfs0 = t.FullSet(); 
  470.   truth(atans3.IsSubset(tfs0), TRUE);
  471.   truth(tfs0.IsSubset(atans3), TRUE);
  472.  
  473.   truth(atans0.IsIn(p1 - p1), TRUE);
  474.   truth(atans0.IsIn(p2 - p1), FALSE);
  475.   truth(atans0.IsIn(p3 - p1), FALSE);
  476.   truth(atans0.IsIn(p4 - p1), FALSE);
  477.  
  478.   truth(atans1.IsIn(p1 - p1), TRUE);
  479.   truth(atans1.IsIn(p2 - p1), TRUE);
  480.   truth(atans1.IsIn(p3 - p1), FALSE);
  481.   truth(atans1.IsIn(p4 - p1), FALSE);
  482.  
  483.   truth(atans2.IsIn(p1 - p1), TRUE);
  484.   truth(atans2.IsIn(p2 - p1), TRUE);
  485.   truth(atans2.IsIn(p3 - p1), TRUE);
  486.   truth(atans2.IsIn(p4 - p1), FALSE);
  487.  
  488.   truth(atans3.IsIn(p1 - p1), TRUE);
  489.   truth(atans3.IsIn(p2 - p1), TRUE);
  490.   truth(atans3.IsIn(p3 - p1), TRUE);
  491.   truth(atans3.IsIn(p4 - p1), TRUE);
  492.  
  493.  
  494. // Affine subsets of tangent vector spaces:
  495.  
  496.   beauty();
  497.   truth(as0dt.Accepts() == AFF_VECTOR, TRUE);
  498.   truth(as1dt.Accepts() == AFF_VECTOR, TRUE);
  499.   truth(as2dt.Accepts() == AFF_VECTOR, TRUE);
  500.  
  501.   truth(as0dt.IsFullSpace(), FALSE);
  502.   truth(as1dt.IsFullSpace(), FALSE);
  503.   truth(as2dt.IsFullSpace(), FALSE);
  504.  
  505.   truth(as0dt.IsSubset(as0dt), TRUE);
  506.   truth(as1dt.IsSubset(as0dt), TRUE);
  507.   truth(as2dt.IsSubset(as0dt), TRUE);
  508.  
  509.   truth(as0dt.IsSubset(as1dt), FALSE);
  510.   truth(as1dt.IsSubset(as1dt), TRUE);
  511.   truth(as2dt.IsSubset(as1dt), TRUE);
  512.  
  513.   truth(as0dt.IsSubset(as2dt), FALSE);
  514.   truth(as1dt.IsSubset(as2dt), FALSE);
  515.   truth(as2dt.IsSubset(as2dt), TRUE);
  516.  
  517.   truth(as0dt.IsIn(t1), TRUE);
  518.   truth(as0dt.IsIn(t2), FALSE);
  519.   truth(as0dt.IsIn(t3), FALSE);
  520.  
  521.   truth(as1dt.IsIn(t1), TRUE);
  522.   truth(as1dt.IsIn(t2), TRUE);
  523.   truth(as1dt.IsIn(t3), FALSE);
  524.  
  525.   truth(as2dt.IsIn(t1), TRUE);
  526.   truth(as2dt.IsIn(t2), TRUE);
  527.   truth(as2dt.IsIn(t3), TRUE);
  528.  
  529. // Associated tangent subsets:
  530.  
  531.   VSubSet ttans0 = as0dt.TangentSub();  
  532.   VSubSet ttans1 = as1dt.TangentSub();  
  533.   VSubSet ttans2 = as2dt.TangentSub();  
  534.  
  535.   beauty();
  536.   truth(ttans0.Accepts() == AFF_VECTOR, TRUE);
  537.   truth(ttans1.Accepts() == AFF_VECTOR, TRUE);
  538.   truth(ttans2.Accepts() == AFF_VECTOR, TRUE);
  539.  
  540.   truth(ttans0.IsFullSpace(), FALSE);
  541.   truth(ttans1.IsFullSpace(), FALSE);
  542.   truth(ttans2.IsFullSpace(), FALSE);
  543.  
  544.   truth(ttans0.IsSubset(ttans0), TRUE);
  545.   truth(ttans1.IsSubset(ttans0), TRUE);
  546.   truth(ttans2.IsSubset(ttans0), TRUE);
  547.  
  548.   truth(ttans0.IsSubset(ttans1), FALSE);
  549.   truth(ttans1.IsSubset(ttans1), TRUE);
  550.   truth(ttans2.IsSubset(ttans1), TRUE);
  551.  
  552.   truth(ttans0.IsSubset(ttans2), FALSE);
  553.   truth(ttans1.IsSubset(ttans2), FALSE);
  554.   truth(ttans2.IsSubset(ttans2), TRUE);
  555.  
  556.   truth(ttans0.IsIn(t1 - t1), TRUE);
  557.   truth(ttans0.IsIn(t2 - t1), FALSE);
  558.   truth(ttans0.IsIn(t3 - t1), FALSE);
  559.  
  560.   truth(ttans1.IsIn(t1 - t1), TRUE);
  561.   truth(ttans1.IsIn(t2 - t1), TRUE);
  562.   truth(ttans1.IsIn(t3 - t1), FALSE);
  563.  
  564.   truth(ttans2.IsIn(t1 - t1), TRUE);
  565.   truth(ttans2.IsIn(t2 - t1), TRUE);
  566.   truth(ttans2.IsIn(t3 - t1), TRUE);
  567.  
  568. // Affine subsets of projective spaces:
  569.  
  570.   beauty();
  571.   truth(as1dp.Accepts() == PROJ_POINT, TRUE);
  572.   truth(as2dp.Accepts() == PROJ_POINT, TRUE);
  573.   truth(as3dp.Accepts() == PROJ_POINT, TRUE);
  574.  
  575.   truth(as1dp.IsFullSpace(), FALSE);
  576.   truth(as2dp.IsFullSpace(), FALSE);
  577.   truth(as3dp.IsFullSpace(), FALSE);
  578.  
  579.   GeObList inf1 = as1dp.AtInfinity();
  580.   GeObList inf2 = as2dp.AtInfinity();
  581.   GeObList inf3 = as3dp.AtInfinity();
  582.  
  583.   truth(inf1.Length() == 1, TRUE);
  584.   truth(inf2.Length() == 2, TRUE);
  585.   truth(inf3.Length() == 3, TRUE);
  586.  
  587.   truth(as1dp.IsIn(inf1[0]), FALSE);
  588.   truth(as2dp.IsIn(inf2[0]), FALSE);
  589.   truth(as2dp.IsIn(inf2[1]), FALSE);
  590.   truth(as3dp.IsIn(inf3[0]), FALSE);
  591.   truth(as3dp.IsIn(inf3[1]), FALSE);
  592.   truth(as3dp.IsIn(inf3[2]), FALSE);
  593.  
  594.   truth(as1dp.IsSubset(as1dp), TRUE);
  595.   truth(as2dp.IsSubset(as1dp), TRUE);
  596.   truth(as3dp.IsSubset(as1dp), TRUE);
  597.  
  598.   truth(as1dp.IsSubset(as2dp), FALSE);
  599.   truth(as2dp.IsSubset(as2dp), TRUE);
  600.   truth(as3dp.IsSubset(as2dp), TRUE);
  601.  
  602.   truth(as1dp.IsSubset(as3dp), FALSE);
  603.   truth(as2dp.IsSubset(as3dp), FALSE);
  604.   truth(as3dp.IsSubset(as3dp), TRUE);
  605.  
  606.   truth(as1dp.IsIn(pp1), TRUE);
  607.   truth(as1dp.IsIn(pp2), FALSE);
  608.   truth(as1dp.IsIn(holdec), FALSE);
  609.   truth(as1dp.IsIn(pp4), FALSE);
  610.  
  611.   PPoint holdpp = (pp1 + pp2) / 2.0; 
  612.   truth(as1dp.IsIn(holdpp), TRUE);
  613.  
  614. // A kludge, but affine combinations work because points at infinity
  615. // in these subsets are not points at infinity in standard subset:
  616.  
  617.   truth(as2dp.IsIn(pp1), TRUE);
  618.   truth(as2dp.IsIn(pp2), FALSE);
  619.   truth(as2dp.IsIn(holdec), FALSE);
  620.   truth(as2dp.IsIn(pp4), FALSE);
  621.  
  622.   holdpp = (pp1 + pp2 + pp3) / 3; 
  623.   truth(as2dp.IsIn(holdpp), TRUE);
  624.  
  625.   truth(as3dp.IsIn(pp1), TRUE);
  626.   truth(as3dp.IsIn(pp2), FALSE);
  627.   truth(as3dp.IsIn(holdec), FALSE);
  628.   truth(as3dp.IsIn(pp4), FALSE);
  629.  
  630.   holdpp = (pp1 + pp2 + pp3 + pp4) / 4; 
  631.   truth(as3dp.IsIn(holdpp), TRUE);
  632.  
  633. // Projective subsets of projective spaces:
  634.  
  635.   beauty();
  636.   truth(ps0dp.Accepts() == PROJ_POINT, TRUE);
  637.   truth(ps1dp.Accepts() == PROJ_POINT, TRUE);
  638.   truth(ps2dp.Accepts() == PROJ_POINT, TRUE);
  639.   truth(ps3dp.Accepts() == PROJ_POINT, TRUE);
  640.  
  641.   truth(ps0dp.IsFullSpace(), FALSE);
  642.   truth(ps1dp.IsFullSpace(), FALSE);
  643.   truth(ps2dp.IsFullSpace(), FALSE);
  644.   truth(ps3dp.IsFullSpace(), TRUE);
  645.  
  646.   truth(ps0dp.HasRemovedPoints(), FALSE);
  647.   truth(ps1dp.HasRemovedPoints(), FALSE);
  648.   truth(ps2dp.HasRemovedPoints(), FALSE);
  649.   truth(ps3dp.HasRemovedPoints(), FALSE);
  650.  
  651.   truth(ps0dp.IsSubset(ps0dp), TRUE);
  652.   truth(ps1dp.IsSubset(ps0dp), TRUE);
  653.   truth(ps2dp.IsSubset(ps0dp), TRUE);
  654.   truth(ps3dp.IsSubset(ps0dp), TRUE);
  655.  
  656.   truth(ps0dp.IsSubset(ps1dp), FALSE);
  657.   truth(ps1dp.IsSubset(ps1dp), TRUE);
  658.   truth(ps2dp.IsSubset(ps1dp), TRUE);
  659.   truth(ps3dp.IsSubset(ps1dp), TRUE);
  660.  
  661.   truth(ps0dp.IsSubset(ps2dp), FALSE);
  662.   truth(ps1dp.IsSubset(ps2dp), FALSE);
  663.   truth(ps2dp.IsSubset(ps2dp), TRUE);
  664.   truth(ps3dp.IsSubset(ps2dp), TRUE);
  665.  
  666.   truth(ps0dp.IsSubset(ps3dp), FALSE);
  667.   truth(ps1dp.IsSubset(ps3dp), FALSE);
  668.   truth(ps2dp.IsSubset(ps3dp), FALSE);
  669.   truth(ps3dp.IsSubset(ps3dp), TRUE);
  670.  
  671.   PSubSet pfs = p.FullSet(); 
  672.   truth(ps3dp.IsSubset(pfs), TRUE);
  673.   truth(pfs.IsSubset(ps3dp), TRUE);
  674.  
  675.   truth(ps0dp.IsIn(pp1), TRUE);
  676.   truth(ps0dp.IsIn(pp2), FALSE);
  677.   truth(ps0dp.IsIn(holdec), FALSE);
  678.   truth(ps0dp.IsIn(pp4), FALSE);
  679.  
  680.   truth(ps1dp.IsIn(pp1), TRUE);
  681.   truth(ps1dp.IsIn(pp2), TRUE);
  682.   truth(ps1dp.IsIn(holdec), FALSE);
  683.   truth(ps1dp.IsIn(pp4), FALSE);
  684.  
  685.   truth(ps2dp.IsIn(pp1), TRUE);
  686.   truth(ps2dp.IsIn(pp2), TRUE);
  687.   truth(ps2dp.IsIn(holdec), TRUE);
  688.   truth(ps2dp.IsIn(pp4), FALSE);
  689.  
  690.   truth(ps3dp.IsIn(pp1), TRUE);
  691.   truth(ps3dp.IsIn(pp2), TRUE);
  692.   truth(ps3dp.IsIn(holdec), TRUE);
  693.   truth(ps3dp.IsIn(pp4), TRUE);
  694.  
  695. // Projective subsets of vector spaces:
  696.  
  697.   beauty();
  698.   truth(ps0dv.Accepts() == VEC_EC, TRUE);
  699.   truth(ps1dv.Accepts() == VEC_EC, TRUE);
  700.   truth(ps2dv.Accepts() == VEC_EC, TRUE);
  701.   truth(ps3dv.Accepts() == VEC_EC, TRUE);
  702.  
  703.   truth(ps0dv.IsFullSpace(), FALSE);
  704.   truth(ps1dv.IsFullSpace(), FALSE);
  705.   truth(ps2dv.IsFullSpace(), FALSE);
  706.   truth(ps3dv.IsFullSpace(), TRUE);
  707.  
  708.   truth(ps0dv.HasRemovedPoints(), FALSE);
  709.   truth(ps1dv.HasRemovedPoints(), FALSE);
  710.   truth(ps2dv.HasRemovedPoints(), FALSE);
  711.   truth(ps3dv.HasRemovedPoints(), FALSE);
  712.  
  713.   truth(ps0dv.IsSubset(ps0dv), TRUE);
  714.   truth(ps1dv.IsSubset(ps0dv), TRUE);
  715.   truth(ps2dv.IsSubset(ps0dv), TRUE);
  716.   truth(ps3dv.IsSubset(ps0dv), TRUE);
  717.  
  718.   truth(ps0dv.IsSubset(ps1dv), FALSE);
  719.   truth(ps1dv.IsSubset(ps1dv), TRUE);
  720.   truth(ps2dv.IsSubset(ps1dv), TRUE);
  721.   truth(ps3dv.IsSubset(ps1dv), TRUE);
  722.  
  723.   truth(ps0dv.IsSubset(ps2dv), FALSE);
  724.   truth(ps1dv.IsSubset(ps2dv), FALSE);
  725.   truth(ps2dv.IsSubset(ps2dv), TRUE);
  726.   truth(ps3dv.IsSubset(ps2dv), TRUE);
  727.  
  728.   truth(ps0dv.IsSubset(ps3dv), FALSE);
  729.   truth(ps1dv.IsSubset(ps3dv), FALSE);
  730.   truth(ps2dv.IsSubset(ps3dv), FALSE);
  731.   truth(ps3dv.IsSubset(ps3dv), TRUE);
  732.  
  733.   PSubSet vpfs = v.FullProjSet(); 
  734.   truth(ps3dv.IsSubset(vpfs), TRUE);
  735.   truth(vpfs.IsSubset(ps3dv), TRUE);
  736.  
  737.   truth(ps0dv.IsIn(v1ec), TRUE);
  738.   truth(ps0dv.IsIn(v2), FALSE);
  739.   truth(ps0dv.IsIn(v3ec), FALSE);
  740.   truth(ps0dv.IsIn(v4ec), FALSE);
  741.  
  742.   truth(ps1dv.IsIn(v1ec), TRUE);
  743.   truth(ps1dv.IsIn(v2), TRUE);
  744.   truth(ps1dv.IsIn(v3ec), FALSE);
  745.   truth(ps1dv.IsIn(v4), FALSE);
  746.  
  747.   truth(ps2dv.IsIn(v1ec), TRUE);
  748.   truth(ps2dv.IsIn(v2), TRUE);
  749.   truth(ps2dv.IsIn(v3ec), TRUE);
  750.   truth(ps2dv.IsIn(v4), FALSE);
  751.  
  752.   truth(ps3dv.IsIn(v1ec), TRUE);
  753.   truth(ps3dv.IsIn(v2), TRUE);
  754.   truth(ps3dv.IsIn(v3ec), TRUE);
  755.   truth(ps3dv.IsIn(v4), TRUE);
  756.  
  757. // Projective subsets of tangent vector spaces:
  758.  
  759.   beauty();
  760.   truth(ps0dt.Accepts() == AFF_VEC_EC, TRUE);
  761.   truth(ps1dt.Accepts() == AFF_VEC_EC, TRUE);
  762.   truth(ps2dt.Accepts() == AFF_VEC_EC, TRUE);
  763.  
  764.   truth(ps0dt.IsFullSpace(), FALSE);
  765.   truth(ps1dt.IsFullSpace(), FALSE);
  766.   truth(ps2dt.IsFullSpace(), TRUE);
  767.  
  768.   truth(ps0dt.HasRemovedPoints(), FALSE);
  769.   truth(ps1dt.HasRemovedPoints(), FALSE);
  770.   truth(ps2dt.HasRemovedPoints(), FALSE);
  771.  
  772.   truth(ps0dt.IsSubset(ps0dt), TRUE);
  773.   truth(ps1dt.IsSubset(ps0dt), TRUE);
  774.   truth(ps2dt.IsSubset(ps0dt), TRUE);
  775.  
  776.   truth(ps0dt.IsSubset(ps1dt), FALSE);
  777.   truth(ps1dt.IsSubset(ps1dt), TRUE);
  778.   truth(ps2dt.IsSubset(ps1dt), TRUE);
  779.  
  780.   truth(ps0dt.IsSubset(ps2dt), FALSE);
  781.   truth(ps1dt.IsSubset(ps2dt), FALSE);
  782.   truth(ps2dt.IsSubset(ps2dt), TRUE);
  783.  
  784.   PSubSet ptfs = t.FullProjSet(); 
  785.   truth(ps2dt.IsSubset(ptfs), TRUE);
  786.   truth(ptfs.IsSubset(ps2dt), TRUE);
  787.  
  788.   truth(ps0dt.IsIn(t1ec), TRUE);
  789.   truth(ps0dt.IsIn(t2), FALSE);
  790.   truth(ps0dt.IsIn(t3ec), FALSE);
  791.  
  792.   truth(ps1dt.IsIn(t1ec), TRUE);
  793.   truth(ps1dt.IsIn(t2), TRUE);
  794.   truth(ps1dt.IsIn(t3ec), FALSE);
  795.  
  796.   truth(ps2dt.IsIn(t1ec), TRUE);
  797.   truth(ps2dt.IsIn(t2), TRUE);
  798.   truth(ps2dt.IsIn(t3ec), TRUE);
  799.  
  800. // Projective subsets of projective spaces with removed points:
  801.  
  802.   beauty();
  803.   truth(ps0dprmt.Accepts() == PROJ_POINT, TRUE);
  804.   truth(ps0dprml.Accepts() == PROJ_POINT, TRUE);
  805.   truth(ps0dprmp.Accepts() == PROJ_POINT, TRUE);
  806.   truth(ps1dprmt.Accepts() == PROJ_POINT, TRUE);
  807.   truth(ps1dprml.Accepts() == PROJ_POINT, TRUE);
  808.   truth(ps2dprmt.Accepts() == PROJ_POINT, TRUE);
  809.  
  810.   truth(ps0dprmt.IsFullSpace(), FALSE);
  811.   truth(ps0dprml.IsFullSpace(), FALSE);
  812.   truth(ps0dprmp.IsFullSpace(), FALSE);
  813.   truth(ps1dprmt.IsFullSpace(), FALSE);
  814.   truth(ps1dprml.IsFullSpace(), FALSE);
  815.   truth(ps2dprmt.IsFullSpace(), FALSE);
  816.  
  817.   truth(ps0dprmt.HasRemovedPoints(), TRUE);
  818.   truth(ps0dprml.HasRemovedPoints(), TRUE);
  819.   truth(ps0dprmp.HasRemovedPoints(), TRUE);
  820.   truth(ps1dprmt.HasRemovedPoints(), TRUE);
  821.   truth(ps1dprml.HasRemovedPoints(), TRUE);
  822.   truth(ps2dprmt.HasRemovedPoints(), TRUE);
  823.  
  824.   truth(ps0dprmt.IsIn(pp1), FALSE);
  825.   truth(ps0dprmt.IsIn(pp2), TRUE);
  826.   truth(ps0dprmt.IsIn(holdec), FALSE);
  827.   truth(ps0dprmt.IsIn(pp4), FALSE);
  828.  
  829.   truth(ps0dprml.IsIn(pp1), FALSE);
  830.   truth(ps0dprml.IsIn(pp2), FALSE);
  831.   truth(ps0dprml.IsIn(holdec), TRUE);
  832.   truth(ps0dprml.IsIn(pp4), FALSE);
  833.  
  834.   truth(ps0dprmp.IsIn(pp1), FALSE);
  835.   truth(ps0dprmp.IsIn(pp2), FALSE);
  836.   truth(ps0dprmp.IsIn(holdec), FALSE);
  837.   truth(ps0dprmp.IsIn(pp4), TRUE);
  838.  
  839.   truth(ps1dprmt.IsIn(pp1), FALSE);
  840.   truth(ps1dprmt.IsIn(pp2), TRUE);
  841.   truth(ps1dprmt.IsIn(holdec), TRUE);
  842.   truth(ps1dprmt.IsIn(pp4), FALSE);
  843.  
  844.   truth(ps1dprml.IsIn(pp1), FALSE);
  845.   truth(ps1dprml.IsIn(pp2), FALSE);
  846.   truth(ps1dprml.IsIn(holdec), TRUE);
  847.   truth(ps1dprml.IsIn(pp4), TRUE);
  848.  
  849.   truth(ps2dprmt.IsIn(pp1), FALSE);
  850.   truth(ps2dprmt.IsIn(pp2), TRUE);
  851.   truth(ps2dprmt.IsIn(holdec), TRUE);
  852.   truth(ps2dprmt.IsIn(pp4), TRUE);
  853.  
  854. // Projective subsets of vector spaces with removed points:
  855.  
  856.   beauty();
  857.   truth(ps0dvrmt.Accepts() == VEC_EC, TRUE);
  858.   truth(ps0dvrml.Accepts() == VEC_EC, TRUE);
  859.   truth(ps0dvrmp.Accepts() == VEC_EC, TRUE);
  860.   truth(ps1dvrmt.Accepts() == VEC_EC, TRUE);
  861.   truth(ps1dvrml.Accepts() == VEC_EC, TRUE);
  862.   truth(ps2dvrmt.Accepts() == VEC_EC, TRUE);
  863.  
  864.   truth(ps0dvrmt.IsFullSpace(), FALSE);
  865.   truth(ps0dvrml.IsFullSpace(), FALSE);
  866.   truth(ps0dvrmp.IsFullSpace(), FALSE);
  867.   truth(ps1dvrmt.IsFullSpace(), FALSE);
  868.   truth(ps1dvrml.IsFullSpace(), FALSE);
  869.   truth(ps2dvrmt.IsFullSpace(), FALSE);
  870.  
  871.   truth(ps0dvrmt.HasRemovedPoints(), TRUE);
  872.   truth(ps0dvrml.HasRemovedPoints(), TRUE);
  873.   truth(ps0dvrmp.HasRemovedPoints(), TRUE);
  874.   truth(ps1dvrmt.HasRemovedPoints(), TRUE);
  875.   truth(ps1dvrml.HasRemovedPoints(), TRUE);
  876.   truth(ps2dvrmt.HasRemovedPoints(), TRUE);
  877.  
  878.   truth(ps0dvrmt.IsIn(v1ec), FALSE);
  879.   truth(ps0dvrmt.IsIn(v2ec), TRUE);
  880.   truth(ps0dvrmt.IsIn(v3), FALSE);
  881.   truth(ps0dvrmt.IsIn(v4ec), FALSE);
  882.  
  883.   truth(ps0dvrml.IsIn(v1ec), FALSE);
  884.   truth(ps0dvrml.IsIn(v2ec), FALSE);
  885.   truth(ps0dvrml.IsIn(v3), TRUE);
  886.   truth(ps0dvrml.IsIn(v4ec), FALSE);
  887.  
  888.   truth(ps0dvrmp.IsIn(v1ec), FALSE);
  889.   truth(ps0dvrmp.IsIn(v2), FALSE);
  890.   truth(ps0dvrmp.IsIn(v3ec), FALSE);
  891.   truth(ps0dvrmp.IsIn(v4ec), TRUE);
  892.  
  893.   truth(ps1dvrmt.IsIn(v1ec), FALSE);
  894.   truth(ps1dvrmt.IsIn(v2ec), TRUE);
  895.   truth(ps1dvrmt.IsIn(v3), TRUE);
  896.   truth(ps1dvrmt.IsIn(v4ec), FALSE);
  897.  
  898.   truth(ps1dvrml.IsIn(v1ec), FALSE);
  899.   truth(ps1dvrml.IsIn(v2ec), FALSE);
  900.   truth(ps1dvrml.IsIn(v3), TRUE);
  901.   truth(ps1dvrml.IsIn(v4ec), TRUE);
  902.  
  903.   truth(ps2dvrmt.IsIn(v1ec), FALSE);
  904.   truth(ps2dvrmt.IsIn(v2), TRUE);
  905.   truth(ps2dvrmt.IsIn(v3ec), TRUE);
  906.   truth(ps2dvrmt.IsIn(v4ec), TRUE);
  907.  
  908. // Projective subsets of tangent vector spaces with removed points:
  909.  
  910.   beauty();
  911.   truth(ps0dtrmt.Accepts() == AFF_VEC_EC, TRUE);
  912.   truth(ps0dtrml.Accepts() == AFF_VEC_EC, TRUE);
  913.   truth(ps1dtrmt.Accepts() == AFF_VEC_EC, TRUE);
  914.  
  915.   truth(ps0dtrmt.IsFullSpace(), FALSE);
  916.   truth(ps0dtrml.IsFullSpace(), FALSE);
  917.   truth(ps1dtrmt.IsFullSpace(), FALSE);
  918.  
  919.   truth(ps0dtrmt.HasRemovedPoints(), TRUE);
  920.   truth(ps0dtrml.HasRemovedPoints(), TRUE);
  921.   truth(ps1dtrmt.HasRemovedPoints(), TRUE);
  922.  
  923.   truth(ps0dtrmt.IsIn(t1ec), FALSE);
  924.   truth(ps0dtrmt.IsIn(t2), TRUE);
  925.   truth(ps0dtrmt.IsIn(t3ec), FALSE);
  926.  
  927.   truth(ps0dtrml.IsIn(t1ec), FALSE);
  928.   truth(ps0dtrml.IsIn(t2), FALSE);
  929.   truth(ps0dtrml.IsIn(t3ec), TRUE);
  930.  
  931.   truth(ps1dtrmt.IsIn(t1ec), FALSE);
  932.   truth(ps1dtrmt.IsIn(t2ec), TRUE);
  933.   truth(ps1dtrmt.IsIn(t3), TRUE);
  934. }
  935.  
  936.  
  937.  
  938.  
  939.  
  940.  
  941.  
  942.